home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / flc2.arc / FLEXLIST.H < prev    next >
C/C++ Source or Header  |  1990-12-07  |  6KB  |  185 lines
  1. /*
  2.     flexlist.h
  3.     10-4-90
  4.     Homogeneous-heterogeneous 
  5.     hybrid stack-queue-list-array generic class.
  6.     ANSI C
  7.  
  8.     Copyright 1990
  9.     John W. Small
  10.     All rights reserved
  11.  
  12.     PSW / Power SoftWare
  13.     P.O. Box 10072
  14.     McLean, Virginia 22102 8072
  15.     (703) 759-3838
  16. */
  17.  
  18. /* LINTLIBRARY */
  19.  
  20. #ifndef FLEXLIST_ANSI_C
  21. #define FLEXLIST_ANSI_C
  22.  
  23. #include <stddef.h>    /*  size_t  */
  24. #include <limits.h>    /*  UINT_MAX  */
  25.  
  26.  
  27. /*  FlexNode declarations  */
  28.  
  29. typedef struct FlexNode_ FlexNode, *FlexN;
  30. #define FlexN0 ((FlexN)0)
  31. #define FlexNodeLinkage FlexN next, prev
  32.  
  33. struct FlexNode_ {
  34. /*  friend: FlexList  */
  35.     FlexNodeLinkage;
  36. /*  public:  */
  37.     char data[1];
  38. };
  39.  
  40. /*  Virtual functions for variant FlexNodes  */
  41.  
  42. typedef struct  {
  43. /*  friend: FlexList  */
  44.     FlexN (*FNnew)(const void *D);
  45.     int   (*FNwrite)(void *ND, const void *D);
  46.     int   (*FNread)(const void *ND, void *D);
  47.     int   (*FNdestruct)(void *ND, void *D);
  48. } FlexNodeVFT, *FlexNVFT;
  49.  
  50. #define FlexNVFT0 ((FlexNVFT)0)
  51. #define FNnew0 ((FlexN (*)(const void *D)) 0)
  52. #define FNwrite0 ((int (*)(void *ND, const void *D)) 0)
  53. #define FNread0 ((int (*)(const void *ND, void *D)) 0)
  54. #define FNdestruct0 ((int (*)(void *ND, void *D)) 0)
  55.  
  56.  
  57. /*  String variant FlexNode functions  */
  58. extern  FlexNodeVFT FlexNodeStrVFT;
  59.  
  60.  
  61. /*  FlexList header declaration  */
  62.  
  63. typedef struct  {
  64. /*  private:  */
  65.     FlexN  front, current, rear;
  66.     unsigned curNum, nodes, maxNodes;
  67.     size_t sizeofNodeData, sizeofNode;
  68.     int sorted;
  69.     int (*compare)(const void *D1, const void *D2);
  70.     FlexNVFT vft;
  71.     int (*FLDdestruct)(void *LD);
  72.     char data[1];
  73. } FlexList, *FlexL;
  74.  
  75. #define FlexL0 ((FlexL)0)
  76. #define FLcomparE(compare)  ((int (*)(const void *D1, \
  77.         const void *D2)) compare)
  78. #define FLcompare0  FLcomparE(0)
  79. #define FLDdestruct0 ((int (*)(void *LD)) 0)
  80.  
  81.  
  82. /*  FlexList constructors/destructor - static headers  */
  83. extern  FlexL FLfixed(FlexL L, size_t sizeofNodeData);
  84. extern  FlexL FLunpack(FlexL L, size_t sizeofCell, 
  85.         unsigned cells, const void *array);
  86. extern  FlexL FLvariant(FlexL L, FlexNVFT vft);
  87. #define FLstr(L) FLvariant(L,&FlexNodeStrVFT)
  88. extern  int   FLclear(FlexL L);
  89.  
  90. /*  FlexList constructors/destructor - dynamic headers  */
  91. extern  FlexL FLfixedNew(size_t sizeofNodeData,
  92.         size_t sizeofLocalData, 
  93.         int (*FLDdestruct)(void *LD));
  94. extern  FlexL FLunpackNew(size_t sizeofCell, 
  95.         unsigned cells, const void *array,
  96.         size_t sizeofLocalData,
  97.         int (*FLDdestruct)(void *LD));
  98. extern  FlexL FLvariantNew(FlexNVFT vft,
  99.         size_t sizeofLocalData, 
  100.         int (*FLDdestruct)(void *LD));
  101. #define FLstrNew(sizeofLocalData, FLDdestruct)  \
  102.         FLvariantNew(&FlexNodeStrVFT,  \
  103.             sizeofLocalData,FLDdestruct)
  104. extern  int   FLdelete(FlexL *Lptr);
  105.  
  106.  
  107. /*  FlexList header functions  */
  108. #define FLfrontD(L) (void *)((L)? (L)->front? \
  109.         (L)->front->data : 0 : 0)
  110. #define FLcurrentD(L) (void *)((L)? (L)->current? \
  111.         (L)->current->data : 0 : 0)
  112. #define FLrearD(L) (void *)((L)? (L)->rear? \
  113.         (L)->rear->data : 0 : 0)
  114. #define FLcurNum(L) ((L)? (L)->curNum : 0)
  115. #define FLnodes(L)  ((L)? (L)->nodes : 0)
  116. #define FLmaxNodes(L) ((L)? (L)->maxNodes : 0)
  117. extern  int   FLsetMaxNodes(FlexL L, unsigned maxNodes);
  118. #define FLnotFull(L) ((L)? ((L)->maxNodes - (L)->nodes) : 0)
  119. #define FLsizeofNodeData(L) ((L)? (L)->sizeofNodeData : 0)
  120. #define FLisSorted(L)  ((L)? (L)->sorted : 0)
  121. #define FLunSort(L)  ((L)? ((L)->sorted = 0, 1) : 0)
  122. #define FLcompare(L)  ((L)? (L)->compare : FLcompare0)
  123. extern  int   FLsetCompare(FlexL L, int (*compare)
  124.         (const void *D1, const void *D2));
  125. #define FLisFixed(L)  FLsizeofNodeData(L)
  126. #define FLisVariant(L) ((L)? (L)->vft : FlexNVFT0)
  127. #define FLData(L)  (void *)((L)? ((L)->FLDdestruct?  \
  128.         (L)->data : 0) : 0)
  129.  
  130. /*  FlexList stack and queue functions  */
  131. extern  void *FLpushN(FlexL L, FlexN N);
  132. extern  void *FLpushD(FlexL L, const void *D);
  133. extern  FlexN FLpopN(FlexL L);
  134. extern  int   FLpopD(FlexL L, void *D);
  135. extern  void *FLtopD(FlexL L, void *D);
  136. extern  void *FLinsQN(FlexL L, FlexN N);
  137. extern  void *FLinsQD(FlexL L, const void *D);
  138.  
  139. /*  FlexList list functions  */
  140. extern  void *FLmkcur(FlexL L, unsigned n);
  141. extern  void *FLinsN(FlexL L, FlexN N);
  142. extern  void *FLinsD(FlexL L, const void *D);
  143. extern  void *FLinsSortN(FlexL L, FlexN N);
  144. extern  void *FLinsSortD(FlexL L, const void *D);
  145. extern  FlexN FLdelN(FlexL L);
  146. extern  int   FLdelD(FlexL L, void *D);
  147. extern  void *FLnextD(FlexL L, void *D);
  148. extern  void *FLprevD(FlexL L, void *D);
  149.  
  150.  
  151.  
  152. /*  FlexList search/sort functions  */
  153. /*  See also FLinsSortN()/FLinsSortD() list functions  */
  154. extern  void *FLfindFirstD(FlexL L, const void *D);
  155. extern  void *FLfindNextD(FlexL L, const void *D);
  156. extern  void *FLfindLastD(FlexL L, const void *D);
  157. extern  void *FLfindPrevD(FlexL L, const void *D);
  158. extern  int   FLsort(FlexL L, int (*compare)
  159.         (const void *D1, const void *D2));
  160.  
  161. /*  FlexList array functions  */
  162. /*  See also compaction functions */
  163. extern  int   FLstoreD(FlexL L, const void *D, unsigned n);
  164. extern  int   FLrecallD(FlexL L, void *D, unsigned n);
  165.  
  166. /*  FlexList compaction functions  */
  167. /*  See also FLunpack()/FLunpackNew() constructors  */
  168. extern  void *FLpack(FlexL L);
  169. extern  void **FLpackPtrs(FlexL L);
  170.  
  171. /*  FlexList implementation constants  */
  172. /*  Change as required by target machine  */
  173. #define FLmaxMaxNodes  UINT_MAX
  174. #define FLmallocAlignLoss  16
  175. #define FLmaxSizeofLocalData \
  176.     ((size_t)(-(long)sizeof(FlexList) \
  177.     -FLmallocAlignLoss))
  178. #define FLmaxSizeofNodeData  \
  179.     ((size_t)(-(long)sizeof(FlexNode) \
  180.     -FLmallocAlignLoss))
  181. #define FLmaxSizeofArray \
  182.     ((long)(size_t)-FLmallocAlignLoss)
  183.  
  184. #endif
  185.